home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / CRS / crs05.d81 / evsbasic.arc / EVSKEYWORDS.G-I < prev    next >
Text File  |  2009-10-10  |  11KB  |  281 lines
  1. ---------------------------------------
  2.  
  3. GRAPHIC <mode>
  4.  
  5. The GRAPHIC statement sets the current graphic mode.  <Mode> is a numeric
  6. expression which normally ranges from 0 to 5, selecting one of the six
  7. graphic modes provided by EVS Basic.  In addition to setting the graphic
  8. mode, executing this keyword also PAGEs the screen, disables all sprites,
  9. and, if setting a bitmap mode, sets the current pen to Pen 1.  Adding 16 to
  10. the <mode> number causes the PAGE action to be suppressed, leaving both
  11. screen and cursor in an unknown state.  Adding 128 to the <mode> number
  12. turns off the video display, which blanks the screen but also speeds up
  13. text mode program execution by about 7% (bitmap modes are not affected).
  14.  
  15. The six basic graphic modes are described below:
  16.  
  17. Mode  Screen   Color   Charset
  18.  
  19.  0     Text    Normal    ROM
  20.  1     Text    Normal    RAM
  21.  2     Text    Multi     RAM
  22.  3     Text    Extended  RAM
  23.  4    Bitmap   Multi     RAM
  24.  5    Bitmap   Normal    RAM
  25.  
  26. A "Text" mode screen is a character-oriented screen of 1000 cells organized
  27. as 40 columns by 25 rows.  Each cell may contain any of 256 characters.  A
  28. "Bitmap" mode screen is a "dot"-oriented screen of 64,000 pixels organized
  29. as 320 columns by 200 rows.  Each pixel may be either on or off.
  30.  
  31. In any mode, the color of what is displayed on the screen depends heavily
  32. upon 1000 color cells.  These are very similar to the character cells of
  33. the text screens and organized the same way. "Normal" color modes require
  34. the paper color to be the same in all 1000 cells, but allow one different
  35. ink color in each cell.  "Multi" modes increase the number of different
  36. colors in a single cell from two to four at the cost of resolution (each
  37. dot in a multicolor character or bitmap pattern is twice as wide and there
  38. are only half as many).  "Multi" text permits one ink color and three paper
  39. colors in a cell, while "multi" bitmap allows three ink colors and one
  40. paper color.  "Extended" text color is very much like "Normal" text color,
  41. except that in exchange for reducing the number of different characters
  42. allowed from 256 to 64 this mode permits one ink and any one of four paper
  43. colors in a cell.
  44.  
  45. Graphic mode 0 uses the normal V2 Basic "ROM" character set that cannot be
  46. altered by the programmer.  The other modes share a "RAM" character set can
  47. be altered (redefined) by use of the IMAGE statement.
  48.  
  49. Mode 0:  this normal text mode is the same as the normal V2 Basic screen
  50. display.  It is the default EVS Basic mode.  Any execution error resets
  51. this mode so that the error message can always be read.
  52.  
  53. Mode 1:  this normal text mode is the first mode in which sprites and
  54. redefined character images can be made visible.  Otherwise there is no
  55. apparent difference between mode 0 and mode 1.
  56.  
  57. Mode 2:  in multicolor text mode both normal and multicolor characters can
  58. be displayed.  What kind of character appears in a given screen cell is
  59. determined by what its ink color is.  Colors 0 to 7 give a normal
  60. character, while colors 8 to 15 give multicolor characters.
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68. Mode 3:  in extended background color text mode the ink color of a cell is
  69. determined as with modes 0 and 1, but which paper color a cell has is
  70. determined by whether a character is printed as unshifted, shifted,
  71. reversed, or shifted-reversed.  No matter how it is printed it will appear
  72. as the same unshifted character, but on different paper colors.
  73.  
  74. Mode 4:  this is multicolor bitmap mode.  Each cell can support three ink
  75. colors in addition to the paper color.  Resolution is lower in this mode
  76. than in mode 5, so lines can appear more jagged and characters may appear
  77. blockier.
  78.  
  79. Mode 5:  this is normal bitmap mode, in which each cell can support only
  80. the paper color and one ink color, but with twice the resolution of mode 4.
  81. This mode can display smoother lines and more detailed characters.
  82.  
  83. Examples:
  84.  
  85. 10 GRAPHIC 5
  86. 20 GRAPHIC A+16
  87.  
  88. ---------------------------------------
  89.  
  90. IF <condition> THEN/GOTO <statements> [:ELSE <statements>]
  91.  
  92. The V2 Basic statement IF has been modified to accept an optional ELSE
  93. statement on the same program line.  Statements following ELSE are executed
  94. only if <condition> is false.  There is no other change to the behavior of
  95. the IF statement.
  96.  
  97. Examples:
  98.  
  99. 10 IF A>0 GOTO 90
  100. 20 IF A$=B$ THEN PRINT "YES": ELSE PRINT "NO"
  101.  
  102. ---------------------------------------
  103.  
  104. IMAGE <exp>, <def$>
  105.  
  106. The IMAGE statement is used to define sprite and character images.  Which
  107. action is performed depends on whether <exp> is numeric or string.  <Def$>
  108. must contain the binary pattern of the image being defined.
  109.  
  110. If <exp> is numeric, IMAGE interprets it as a sprite image block number.
  111. Sprite image block numbers may range from 0 to 206 (these are the same
  112. image blocks that are assigned to sprites by SPRPIC.  A sprite "looks like"
  113. the image in the image block currently assigned to it).  Only 18 of the
  114. image blocks are guaranteed to be unused by EVS Basic for any other
  115. purpose, however.  All other image blocks will replace parts of either a
  116. RAM character set or the bitmap screen.  It is the programmer's
  117. responsibility to ensure that any such replacements have no effect on the
  118. program (for example, a program that only uses text modes will not be
  119. affected by having the bitmap overwritten with sprite images).  Potential
  120. conflicts are outlined below:
  121.  
  122.  Blocks          Conflict
  123.  
  124.    0-15             None
  125.   16-47       Uppercase Charset
  126.   48-79       Lowercase Charset
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  80-204            Bitmap
  134. 205-206            None
  135.  
  136. If <exp> is a string, the RAM charset pattern of the first character in the
  137. string will be replaced by the pattern in <def$>.  IMAGE replaces the RAM
  138. character image only in the currently active character set, either the
  139. uppercase/graphics set or the lowercase/uppercase set.  An exception here
  140. is that if the first character of the <exp> string is [RVS ON] (CHR$(18)),
  141. the reversed image of the second character in <exp> will be replaced.  If
  142. the first character of <exp> is any other non-printable control character
  143. or <exp> is the null string, an "?UNKNOWN CHAR" error will result.
  144.  
  145. IMAGE redefines as much of an image as possible, either until the image is
  146. completely redefined or until there are no more characters in <def$> (in
  147. which case the rest of the image is left as it is).  A complete character
  148. image is 8 characters long, a complete sprite image 63.  The same sprite or
  149. character image may be redefined as often as desired.
  150.  
  151. Images may be defined in any graphic mode but they cannot be seen in
  152. graphic mode 0.
  153.  
  154. Examples:
  155.  
  156. 10 IMAGE "A", B$
  157. 20 IMAGE A$, BIN$(B$)
  158. 30 FOR I= 1 TO 5: IMAGE I, A$(I): NEXT
  159.  
  160. ---------------------------------------
  161.  
  162. INFIX$([<start>,] <source$>, <replace$> [,<length>])
  163.  
  164.  
  165. The INFIX$() function returns a string in which characters from <replace$>
  166. have overwritten characters in <source$> beginning at <start> and
  167. continuing for <length> characters.
  168.  
  169. <Start> may range from 1 to 255.  If <start> is not specified it is assumed
  170. to be 1 and replacement begins with the first character of <source$>.  If
  171. <start> is larger than the length of <source$>, <source$> is returned.
  172.  
  173. <Source$> and <replace$> may be any legal string expressions.  If <source$>
  174. is the null string, the null string is returned.  If <replace$> is the null
  175. string, <source$> is returned.
  176.  
  177. <Length> may range from 0 to 255.  If <length> is zero <source$> is
  178. returned.  If <length> is not specified it is assumed to be 255.
  179. Replacement continues until <length> is reached or the end of <source$> or
  180. <replace$> is reached, whichever comes first.
  181.  
  182. Examples:
  183.  
  184. 10 A$= INFIX$("ABBBBB","B")
  185. 20 PRINT INFIX$(A$, B$, 5)
  186. 30 A$(I)= INFIX$(10, A$(I), "NULL RECORD")
  187.  
  188. ---------------------------------------
  189.  
  190. INK [<ink1> [,<ink2> [,<ink3>]]]
  191.  
  192. INK sets the colors to be used by the three "pens".  However, since in the
  193.  
  194.  
  195.  
  196.  
  197.  
  198.  
  199. text modes pen 1 is always considered the active pen, only the changes made
  200. to its color will be visible in those modes.
  201.  
  202. Ink colors may range from 0 to 15.  There is no prohibition against two or
  203. more pens sharing the same color.  The default colors of pens 1, 2 and 3
  204. are 14, 1 and 15, respectively.
  205.  
  206. Ink (foreground) colors differ from paper (background) colors in that the
  207. ink color(s) can be different in each of the screen's 1000 color cells (a
  208. color cell colors either one character (text modes) or 64 pixels in an 8x8
  209. block (bitmap modes)).
  210.  
  211. Examples:
  212.  
  213. 10 INK 14, 1, 15
  214. 20 INK , , A+2
  215. 30 INK , A(I)
  216.  
  217. ---------------------------------------
  218.  
  219. INPUT$( <length> [,# <lf#>])
  220.  
  221. INPUT$() returns a string of <length> characters from the keyboard or a
  222. logical file.  INPUT$() accepts many characters which cause INPUT and
  223. INPUT# to terminate (eg., commas, quote marks, semicolons, colons, and
  224. [RETURN]).  INPUT$() terminates execution only when the number of
  225. characters input reaches the desired <length>.  <Length> can be any value
  226. from 0 to 255.  A <length> of zero returns the null string.
  227.  
  228. If <lf#> is not specified INPUT$() accepts input from the keyboard (no
  229. cursor is displayed).  If a <lf#> is specified INPUT$() attempts to input
  230. from the associated device.  For tape and disk files, if the end-of-file
  231. (EOF) marker is reached before <length> characters are input, INPUT$() will
  232. return a string of however many characters have already been obtained.
  233. This condition can be detected by checking the length of the returned
  234. string and/or the status variable ST.  INPUT$() is not recommended for use
  235. with RS232 files.
  236.  
  237. Examples:
  238.  
  239. 10 A$= INPUT$(1)
  240. 20 A$= INPUT$(B, #4)
  241. 30 A$= INPUT$(1, #2): B$= INPUT$(8, #2): IMAGE A$, B$
  242.  
  243. ---------------------------------------
  244.  
  245. INSTR([<start>,] <source$>, <pattern$> [,<matchtype>])
  246.  
  247. The INSTR() function searches <source$> for occurrences of characters in
  248. <pattern$> and returns either the position in <source$> at which the match
  249. condition became true (successful) or zero if the match condition never
  250. became true (unsuccessful).
  251.  
  252. <Start> may range from 1 to 255.  If <start> is not specified it is assumed
  253. to be 1 and matching attempt begins with the first character of <source$>.
  254. If <start> is larger than the length of <source$>, zero is returned.
  255.  
  256. <Source$> and <pattern$> may be any legal string expressions.  If either or
  257. both are the null string, zero is returned.
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265. <Matchtype> may range from 0 to 3.  If <matchtype> is zero or not specified
  266. <source$> is searched for an exact match to <pattern$> ("AND" search).  If
  267. <matchtype> is 1 <source$> is searched for the first character that does
  268. not match any character in <pattern$> ("NOT" search).  If <matchtype> is 2
  269. <source$> is searched for the first character that matches any character in
  270. <pattern$> ("OR" search).  If <matchtype> is 3, INSTR() again searches for
  271. an exact match, except that any "?" character in <pattern$> matches any
  272. character in the same position in <source$> ("WILDCARD" search).
  273.  
  274. Examples:
  275.  
  276. 10 PRINT INSTR("ABCDEF","C")
  277. 20 IF INSTR(A$, "1234567890", 1 )> 0 THEN PRINT "NOT NUMBER"
  278. 30 ON INSTR("RWQ", A$) GOSUB 100, 200, 300
  279. 40 A= INSTR(B, A$, "B?B", 3)
  280.  
  281.